In Search of Semantic Models for Reconciling Futures and Transactional Memory

Transactional memory (TM) [Herlihy and Moss 1993; Shavit and Touitou 1997] is one of the most promising paradigms to synchronize concurrent access to shared state. An extensive amount of work in the area of TM has focused on transaction execution models that assume that the operations of a transaction are issued sequentially. However, there are many cases where it may be beneficial to exploit concurrency within a single transaction.This has motivated the study of abstractions that allow programmers to express parallelism in the context of transactional systems. There are two abstractions that are extremely relevant in this context. One is the abstraction of parallel nesting, where multiple sub-transactions, that are part of an larger outer (also called top-level) transaction, can be launched in parallel, using language constructs such as cobegin/coend, parallelfor, etc. The other is the future [Halstead Jr 1985] abstraction, which lets programmers activate a parallel task and return a future contract, i.e., a promise to deliver the result of the task when the contract is evaluated. Analogously to parallel nesting, futures allow programmers to express when parallelization is useful: at which point in an otherwise sequential program a parallel task should be started (i.e., when the future is created) and when this task needs to be completed (i.e., when the future is evaluated). Differently from the parallel nesting model, however, the future abstraction does not block the execution of the main thread, also called continuation in the context of futures, till the completion of nested parallel transactions. Further, futures are not necessarily evaluated by the thread that created them. Also, a thread may create a future f and, in the continuation of f evaluate a different future f 0 (without having first evaluated f ). Overall, futures are able to generate a wider range of concurrent computations and enable programming patterns not supported by parallel nesting. The abstraction of Futures has been studied for type-specific optimization on long-lived shared data structures [Kogan and Herlihy 2014] and language integration [Welc et al. 2005]. Interestingly, while the combination of parallel nesting and and transactions has been extensively studied in the literature [Barreto et al. 2010; Barreto et al. 2012; Diegues and Cachopo 2013; Agrawal et al. 2008; Baek et al. 2010], we are not aware of works on the combination of futures and TMs — an abstraction which we call Transactional Futures. In this work, we focus on the problem of defining desirable atomicity and isolation semantics for systems in which futures are used to coordinate the execution of parallel tasks, and whose accesses to shared data are synchronized via transactions. We start by illustrating, via a set of examples of concurrent computations with increasing complexity, the spectrum of issues that need to be addressed when defining the semantics of transactional futures. We show that, given the futures’ ability to generate parallel computations with complex dependency graphs, there are different alternatives to define the notion of atomicity between a future and its continuation. On the basis of these considerations, we formalize four different semantics over two dimensions: the degree of atomicity between futures and continuations, and their admitted serialization orders. The proposed semantics are defined on the basis of a graph-based characterization of the dependencies developed by transactions, both by interacting via reads or writes to shared variables and via the creation and evaluation of futures.